<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>

</body>
<script>
    /************************
     * 数组方法
     * ***********************/
    var array = [1, 2, 3];

    array.join([p])
    /* 作用：
     数组的每一项用拼接符拼成一个字符串返回
     参数：
     [p]：可选，拼接符，默认是逗号
     *  返回值：string
     * 		1.不传参，每一项用逗号拼接
     *      2.拼接符是空字符串，每一项直接拼接
     *      3.拼接符拼接返回
     * */

    array.push(val1,val2...);
    /*作用：
     向数组的最后添加数据
     参数：
     添加的数据，多个数据间用逗号分隔
     返回值：number
     新数组的长度（多少个数据）
     *
     * */

    array.pop()
    /** 作用：
     * 	   删除数组最后一个数据
     * 返回值：混合
     * 	  删除的那一个数据
     * */

    array.shift()
    /** 作用：
     * 	   删除数组第一位数据
     * 返回值：混合
     * 	  返回删除的那一个数据
     * */

    array.unshift(val1,val2...)
    /*作用：
     向数组的头部添加数据
     参数：
     添加的数据，多个数据之间用逗号分隔
     返回值：number
     新数组的长度
     * */

    array.indexOf(target,[start])
    /*作用：
     从指定位置开始查找数组里是否有指定值
     参数：
     target：要找的值
     [start]:可选，起始位置，默认是0
     返回值：number
     1.找到返回位置下标
     2.没找到返回-1
     3.从左向右
     * */

    array.lastIndexOf(target,[start])
    /*作用：
     从指定位置开始查找数组里是否有指定值
     参数：
     target：要找的值
     [start]:可选，起始位置，默认是最后一位
     返回值：number
     1.找到返回位置下标
     2.没找到返回-1
     3.从右向左
     * */

    array.includes(target)
    /** 作用：
     * 		数组里是否包含指定值
     * 参数：
     * 	target:指定值
     * 返回值：boolean
     * 		1.有,true
     *      2.没有,false
     *      3.===
     * */

    array.slice(start,[end])
    /* 作用：
     截取数组中的一段数据放新数组里返回
     参数：
     start：起始位置
     [end]:终止位置，可选，默认到最后一位
     返回值：array
     1.不传参数，返回完整新数组
     2.截取起始位置到终止位置的数据，不包含终止位置，放新数组里返回
     3.负数，长度+负数

     简而言之一句话，当slice()没有输入参数的时候，会创建一个新数组，然后把当前数组的所有元素扔进去，最后返回这个新数组。
     * */

    array.splice(pos,length,val1,val2...)
    /*作用：
     添加，删除，替换
     参数：
     pos:位置
     length:删除长度
     val1,val2:添加数据，多个用逗号分隔
     添加数据时：length为0
     返回值：array
     1.如果有删除，把删除项放到数组里返回
     2.没删除，返回空数组
     3.操作的是原数组
     * */

    array.concat(val1,val2...)
    /** 作用：
     * 		原数组和传入值放新数组里返回，连接2个数组
     * 参数：
     * 	val1,val2:添加的数据，多个之间用逗号
     * 返回值：array
     * 		1.原数组和新传入的值放到新数组里返回
     *      2.不改变原数组
     *      3.如果传入的是数组，会把原数组每项和传入数组的每项放到新数组里返回
     * */

    array.reverse()
    /*作用：
     数组数据前后颠倒顺序排序
     *  返回值：array
     * 		排序后的原数组
     * */


    array.sort([fn])
    /*作用：
     数组每项排序，默认按照uNike码排列
     参数:
     [fn]:处理函数，根据return后边的结果，>0,<0
     返回值：array
     1.排序后的原数组
     2.不传参数，按字符的ASCII码的大小排序
     3.传入处理函数，根据return的结果排序
     //从小到大
     return a-b;

     //从大到小
     return b-a;

     //随机
     return Math.random()-0.5
     * */


    Array.from(arr)
    /** 作用：
     ES6，把类数组，或者有length的对象转成真正的数组
     * 参数：
     * 	  arr:类数组，或者有length对象，类数组：arguments，获取元素tag,class
     * */



    array.forEach(fn,[this])
    /* 循环，遍历，迭代
     作用：
     * 		遍历数组
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     *	不可以break和continue
     *  可以return
     * */


    array.every(fn,[this])
    /* * 作用：
     * 		每次都满足判断条件返回true，有一个不满足就返回false
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     * return  判断条件
     * */


    array.some(fn,[this])
    /** 作用：
     * 		有一个满足判断条件返回true，都不满足就返回false
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     * return  判断条件
     * */


    array.map(fn,[this])
    /** 作用：
     * 		每次循环return后的执行结果成为每项，返回新数组
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     * return  执行语句
     * */

    array.filter(fn,[this])
    /* 作用：
     * 		满足条件的项放到新数组里返回，没有满足项返回空数组
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     * return  判断条件
     * */


    array.find(fn,[this])
    /** 作用：
     * 		满足条件的第一项返回，没有满足项返回undefined
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     * return  判断条件
     * */


    array.findIndex(fn,[this])
    /* * 作用：
     * 		返回满足条件的第一项的下标，如果没有满足项返回-1,ES6
     * 参数：
     * 		fn：处理函数
     *     [this]:可选，处理函数的this指向
     *
     * function(value,index,arr){}
     * value:数组每项值
     * index:索引
     * arr:数组
     *
     * return  判断条件
     * */


    array.fill(val,[start],[end])
    /*作用：
     数组里的项用指定值填充(替换)
     参数：
     val：要变成的值
     [start]：起始位置，可选，默认是0
     [end]:结束位置，可选，默认是最后一位
     返回值：array
     返回填充后的原数组
     * */


    array.copyWithin(pos,[start],[end])
    /*作用：
     ES6，复制范围内的数据，从要替换位置开始替换，复制到几个，就替换几个

     * 参数：
     * 	pos:要替换的位置
     *  [start]:复制数据的起始位置，默认是0
     *  [end]:复制数据的结束位置，默认是最后一位
     * */

    for of
            /* ES6,专门遍历数组用的
             只遍历数组内，数组上的自定义属性和原型上的属性不会被遍历

             for in专门遍历对象{}
             for of专门遍历数组
             * */


    Array.isArray(array)
    /*检测arr是不是数组
     是数组返回true,不是返回false
     * */

</script>
</html>